TypeScript 高级类型守卫：自定义谓词函数与运行时验证

            
function isMyCustomType(variable: any): variable is MyCustomType {
  // Implementation to check if 'variable' conforms to 'MyCustomType'
  return /* boolean indicating if it is MyCustomType */;
}

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  role: 'admin';
  permissions: string[];
}

type Profile = UserProfile | AdminProfile;

            

              
                Copy
              
            
          

            
function isAdminProfile(profile: Profile): profile is AdminProfile {
  return profile.role === 'admin';
}

            

              
                Copy
              
            
          

            
function displayUserProfile(profile: Profile) {
  console.log(`Username: ${profile.username}`);

  if (isAdminProfile(profile)) {
    // Inside this block, 'profile' is narrowed to AdminProfile
    console.log(`Role: ${profile.role}`);
    console.log(`Permissions: ${profile.permissions.join(', ')}`);
  } else {
    // Inside this block, 'profile' is narrowed to UserProfile (or the non-admin part of the union)
    console.log('This user has standard privileges.');
  }
}

const regularUser: UserProfile = { id: 'u1', username: 'alice' };
const adminUser: AdminProfile = { id: 'a1', username: 'bob', role: 'admin', permissions: ['read', 'write', 'delete'] };

displayUserProfile(regularUser);
// Output:
// Username: alice
// This user has standard privileges.

displayUserProfile(adminUser);
// Output:
// Username: bob
// Role: admin
// Permissions: read, write, delete

            

              
                Copy
              
            
          

            
interface Product {
  id: string;
  name: string;
  price: number;
}

function isProduct(data: any): data is Product {
  if (typeof data !== 'object' || data === null) {
    return false;
  }
  const hasId = typeof (data as any).id === 'string';
  const hasName = typeof (data as any).name === 'string';
  const hasPrice = typeof (data as any).price === 'number';
  return hasId && hasName && hasPrice;
}

// Example usage with potentially untrusted data
const apiResponse = {
  id: 'p123',
  name: 'Global Gadget',
  price: 99.99,
  // might have extra properties or missing ones
};

if (isProduct(apiResponse)) {
  // TypeScript knows apiResponse is a Product here
  console.log(`Product: ${apiResponse.name}, Price: ${apiResponse.price}`);
} else {
  console.error('Invalid product data received.');
}

            

              
                Copy
              
            
          

            
npm install zod
# or
yarn add zod

            

              
                Copy
              
            
          

            
import { z } from 'zod';

// Define a Zod schema
const ProductSchema = z.object({
  id: z.string().uuid(), // Example: expecting a UUID string
  name: z.string().min(1, 'Product name cannot be empty'),
  price: z.number().positive('Price must be positive'),
  tags: z.array(z.string()).optional(), // Optional array of strings
});

// Infer the TypeScript type from the Zod schema
type Product = z.infer<typeof ProductSchema>;

// Function to process product data (e.g., from an API)
function processProductData(data: unknown): Product {
  try {
    const validatedProduct = ProductSchema.parse(data);
    // If parsing succeeds, validatedProduct is of type Product
    return validatedProduct;
  } catch (error) {
    console.error('Data validation failed:', error);
    // In a real app, you might throw an error or return a default/null value
    throw new Error('Invalid product data format.');
  }
}

// Example usage:
const rawApiResponse = {
  id: 'a1b2c3d4-e5f6-7890-1234-567890abcdef',
  name: 'Advanced Widget',
  price: 150.75,
  tags: ['electronics', 'new']
};

try {
  const product = processProductData(rawApiResponse);
  console.log(`Successfully processed: ${product.name}`);
} catch (e) {
  console.error('Failed to process product.');
}

const invalidApiResponse = {
  id: 'invalid-id',
  name: '',
  price: -10
};

try {
  const product = processProductData(invalidApiResponse);
  console.log(`Successfully processed: ${product.name}`);
} catch (e) {
  console.error('Failed to process product.');
}
// Expected output for invalid data:
// Data validation failed: [ZodError details...]
// Failed to process product.

            

              
                Copy
              
            
          

            
interface Circle {
  kind: 'circle';
  radius: number;
}

interface Square {
  kind: 'square';
  sideLength: number;
}

type Shape = Circle | Square;

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.sideLength ** 2;
    // TypeScript ensures all cases are handled if type safety is maintained
  }
}

// Runtime validation for discriminated unions
function isShape(data: any): data is Shape {
  if (typeof data !== 'object' || data === null) {
    return false;
  }

  // Check for the discriminant property
  if (!('kind' in data) || (data.kind !== 'circle' && data.kind !== 'square')) {
    return false;
  }

  // Further validation based on the kind
  if (data.kind === 'circle') {
    return typeof data.radius === 'number' && data.radius > 0;
  } else if (data.kind === 'square') {
    return typeof data.sideLength === 'number' && data.sideLength > 0;
  }

  return false; // Should not be reached if kind is valid
}

// Example with potentially untrusted data
const apiData = {
  kind: 'circle',
  radius: 10,
};

if (isShape(apiData)) {
  // TypeScript knows apiData is a Shape here
  console.log(`Area: ${getArea(apiData)}`);
} else {
  console.error('Invalid shape data.');
}

            

              
                Copy
              
            
          

            
type IsAdmin<T> = T extends { role: 'admin' } ? true : false;

type UserStatus = IsAdmin<AdminProfile>;
// UserStatus will be 'true'

            

              
                Copy